import I18nAPI from '@/api/admin/admin/i18n';
import { cacheManager } from './cache'; // 引入缓存管理器

class I18nLoader {
  constructor() {
    // 内存缓存，用于存储当前会话中已加载的语言包
    this.memoryCache = new Map();
    // 用于防止同一语言包在短时间内被重复请求
    this.loadingPromises = new Map();
  }

  /**
   * 加载翻译数据，集成了内存缓存和持久化缓存
   * @param {string} code - 语言代码 (e.g., 'zh-cn')
   * @returns {Promise<Object>} - 翻译数据对象
   */
  async loadTranslations(code) {
    // 1. 检查内存缓存
    if (this.memoryCache.has(code)) {
      return this.memoryCache.get(code);
    }

    // 2. 检查是否正在进行网络请求
    if (this.loadingPromises.has(code)) {
      return this.loadingPromises.get(code);
    }

    const cacheKey = `translations_${code}`;
    let latestVersion = null; // 用于存储从后端获取的最新版本号
    let fetchedData = null; // 用于存储从后端获取的原始数据（包含版本）

    // --- 新增逻辑：首先尝试从后端获取最新版本信息和数据 ---
    // 这一步是关键，我们需要知道当前语言包的最新版本才能正确地进行缓存比较
    try {
      fetchedData = await this.fetchTranslations(code); // 现在fetchTranslations会返回{ translations, version }
      console.log('fetchedData', fetchedData);
      latestVersion = fetchedData.version;
      console.log(
        `[i18nLoader] Fetched latest version for '${code}': ${latestVersion}`,
      );
    } catch (error) {
      console.error(
        `[i18nLoader] Failed to fetch latest translations for ${code}:`,
        error,
      );
      // 如果首次获取失败，尝试从缓存加载旧数据，以防网络问题导致完全无法加载
      const cachedDataOnError = await cacheManager.get(cacheKey, null); // 此时不进行版本比较
      if (cachedDataOnError) {
        console.warn(
          `[i18nLoader] Using cached data for '${code}' due to network error.`,
        );
        this.memoryCache.set(code, cachedDataOnError);
        return cachedDataOnError;
      }
      throw error; // 如果缓存也没有，则抛出错误
    }

    // 3. 检查持久化缓存 (localforage)，现在传入最新版本号进行比较
    const cachedTranslations = await cacheManager.get(cacheKey, latestVersion);
    if (cachedTranslations) {
      console.log(
        `[i18nLoader] Loaded translations for '${code}' from persistent cache (version: ${latestVersion}).`,
      );
      this.memoryCache.set(code, cachedTranslations); // 存入内存缓存
      return cachedTranslations;
    }

    // 4. 如果缓存中没有，或者缓存已过期（版本或时间），则使用刚刚从后端获取的数据
    console.log(
      `[i18nLoader] No valid cache found for '${code}' or cache outdated. Using freshly fetched data.`,
    );
    // 将新获取的数据存入内存缓存和持久化缓存
    this.memoryCache.set(code, fetchedData.translations);
    await cacheManager.set(
      cacheKey,
      fetchedData.translations,
      fetchedData.version || '1.0.0',
    ); // 使用实际版本号
    return fetchedData.translations;
  }

  /**
   * 从服务器获取翻译数据
   * @param {string} code - 语言代码
   * @returns {Promise<Object>} - 翻译数据
   */
  async fetchTranslations(code) {
    try {
      const response = await I18nAPI.getTranslations({ code });
      // 假设 response 的结构是 { success: true, code: 200, data: translations, version: 'x.y.z', message: '' }
      if (response && response.data) {
        return {
          translations: response.data.translations,
          version: response.data.version || '1.0.0',
        }; // 确保返回版本号
      } else {
        throw new Error('Invalid response format from i18n API');
      }
    } catch (error) {
      console.error(
        `[i18nLoader] Failed to fetch translations for ${code}:`,
        error,
      );
      throw error;
    }
  }

  /**
   * 获取支持的语言列表
   * @returns {Promise<Array>} - 语言代码列表
   */
  async getLanguages() {
    const cacheKey = 'supported_languages';
    let latestLanguages = null; // 用于存储从后端获取的最新语言列表
    let latestVersion = null; // 用于存储从后端获取的最新版本号

    // 1. 首先从后端获取最新的语言列表和版本号
    try {
      const response = await I18nAPI.getLangList();
      latestLanguages = response.data.languages;
      latestVersion = response.data.version; // 获取到后端提供的版本号
      console.log(
        `[i18nLoader] Fetched latest language list (version: ${latestVersion}).`,
      );
    } catch (error) {
      console.error(
        '[i18nLoader] Failed to fetch latest language list from server:',
        error,
      );
      // 如果从服务器获取失败，尝试从缓存加载旧数据作为备用
      const cachedDataOnError = await cacheManager.get(cacheKey, null); // 此时不进行版本比较
      if (cachedDataOnError) {
        console.warn(
          `[i18nLoader] Using cached language list due to network error.`,
        );
        return cachedDataOnError;
      }
      throw error; // 如果缓存也没有，则抛出错误
    }

    // 2. 使用获取到的最新版本号去检查持久化缓存
    // cacheManager.get 会比较 latestVersion 和缓存中的版本，如果缓存过期则返回 null
    const cachedData = await cacheManager.get(cacheKey, latestVersion);
    if (cachedData) {
      console.log(
        `[i18nLoader] Loaded supported languages from persistent cache (version: ${latestVersion}).`,
      );
      return cachedData;
    }

    // 3. 如果缓存中没有，或者缓存已过期（版本不匹配或时间过期），则使用刚刚从后端获取的最新数据
    console.log(
      `[i18nLoader] No valid cache found for language list or cache outdated. Using freshly fetched data.`,
    );
    await cacheManager.set(cacheKey, latestLanguages, latestVersion || '1.0.0'); // 存储最新数据和版本号
    return latestLanguages;
  }

  /**
   * 清除缓存
   * @param {string} [code] - 可选，指定语言代码。不传则清除所有缓存。
   */
  async clearCache(code) {
    if (code) {
      this.memoryCache.delete(code);
      await cacheManager.remove(`translations_${code}`);
      console.log(`[i18nLoader] Cleared cache for '${code}'.`);
    } else {
      this.memoryCache.clear();
      await cacheManager.clear();
      console.log('[i18nLoader] Cleared all caches.');
    }
  }
}

// 创建单例实例
export const i18nLoader = new I18nLoader();

export default I18nLoader;
